import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2022-11-21
 * Time: 18:09
 */
public class test {

    //day 1
    public static void fun() {
        Scanner scanner = new Scanner(System.in);

        String s1 = scanner.nextLine();
        String s2 = scanner.nextLine();
        HashSet set = new HashSet<>();
        for (int i = 0; i < s1.length(); i++) {
            set.add(s1.charAt(i));
        }
        for (int i = 0; i < s2.length(); i++) {
            if (!set.contains(s2.charAt(i))) {
                System.out.print(s2.charAt(i));
            }
        }
    }

    public static long fun1() {
        Scanner scanner = new Scanner(System.in);
        long sum = 0;
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            long[] arr = new long[n * 3]; // 存储 每个选手得水平值
            for (int i = 0; i < 3 * n; i++) {
                arr[i] = scanner.nextLong(); // 观察题意可知nextInt存储不下
            }
            // 排序
            Arrays.sort(arr);
            // 1 2 3 4 5 6 7 8 9  -- 1 8 9, 2 6 7, 3 4 5;
            for (int i = 0; i < n; i++) {
                sum += arr[arr.length - 2 * (i + 1)];
            }
        }
        return sum;
    }

    // day 2
    public static int fun2() {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 数组长度
        int[] arr = new int[n + 1];
        int len = 0;
        while (scanner.hasNextInt()) {
            // 存储数据
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextInt();
            }
            int i = 0;
            len = 0;
            while (i < n) {
                // 递增
                if (arr[i] < arr[i + 1]) {
                    // 向后继续执行 -- 前提为i不越界,且满足升序
                    while (i < n && arr[i] < arr[i + 1]) {
                        i++;
                    }
                    // 此时已经非递增 (arr[i+1] <= arr[i]) 则之前为一组
                    len++;
                    // i+1 为下一组子序列开头
                    i++;
                }
                // 相等 -- 既不递增也不递减序列 -- 继续向后排序
                else if (arr[i] == arr[i + 1]) {
                    while (i < n && arr[i] == arr[i + 1]) {
                        i++;
                    }
                    // 此时 arr[i+1] > arr[i]  或者  arr[i+1] < arr[i] 则当前arr[i]与之前分为一组
                    i++;
                }
                // 递减
                else {
                    while (i < n && arr[i] > arr[i + 1]) {
                        i++;
                    }
                    len++;
                    i++;
                }
            }
        }
        return len;
    }

    public static void fun3() {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] array = new int[n];


        for (int j = 0; j < n; j++) {
            array[j] = scanner.nextInt();
        }
        int j = 0;
        int sum = 0;
        while (j < array.length - 1) {
            if (array[j] >= array[j + 1]) {
                while (j < array.length - 1 && array[j] >= array[j + 1]) {
                    j++;
                }
                j++;
            } else {
                while (j < array.length - 1 && array[j] <= array[j + 1]) {
                    j++;
                }
                j++;
            }
            sum++;

        }
        System.out.println(sum);

    }


    public static void reverse(char[] arr, int st, int end) {
        while (st < end) {
            char tmp = arr[st];
            arr[st] = arr[end];
            arr[end] = tmp;
            st++;
            end--;
        }
    }

    public static void fun4(String s) {
        Scanner scan = new Scanner(System.in);

        // 1.转为字符数组
        char[] arr = s.toCharArray();
        // 2. 整体逆置
        int len = arr.length;
        reverse(arr, 0, len - 1);
        // 3. 单个单词分布逆置
        int i = 0;

        while (i < len) {
            int j = i;  // 寻找到一个单词时，需要重置 j 的位置， 让其跳过空格

            // 寻找单词
            while (j < len && arr[j] != ' ') {
                j++;
            }

            if (j < len) {
                //逆置单词
                reverse(arr, i, j - 1);
                // j下标 此时指向 空格 位置
                i = j + 1;
            } else {
                // 当j  > len 时，字符已经遍历完 此时为遇到空格，逆置该单词
                reverse(arr, i, j - 1);
                // 结束循环条件
                i = j;
            }
        }

        // 4. 将字符数组转为字符串
        String array = new String(arr);
        System.out.println(array);

    }


    // day 3

    public static void fun4() {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        int count = 0; // 记录数字的有效个数
        int max = 0; // 记录数字区间的最大值
        int end = 0; // 记录没个数字区间的开头
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                count++;
                if (max < count) {
                    // 更新最大数字区间
                    max = count;
                    // 记录当前数字区间的最后一个数字的下标
                    end = i;
                }
            } else {
                // 不是数字为字母, 重置 count
                count = 0;
            }
        }
        // 将最大位置的数字区间转为字串输出
        // 最后时, end 指向最长数字串的最后一个数字的下标, max为当前最长数字串的数字个数
        System.out.println(s.subSequence(end - max + 1, end + 1));

    }

    public static int fun5(int[] arr) {
        // 投票法
        int ret = arr[0]; // 假定一个众数
        int count = 1;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] == ret) {
                // 相同, 得一票
                count++;
            } else {
                // 不相同 扣一票
                count--;
            }

            if (count == 0) {
                // 当count为0 时, 说明 此时前面得都数目一样多, 当前数一定不是众数
                // 设当前下标元素为 众数, 并重置票数
                ret = arr[i];
                count = 1;
            }
        }

        return ret;
    }


    //day 4

    /**
     * 给定一个十进制数M，以及需要转换的进制数N。将十进制数M转化为N进制数
     */
    public static void fun6() {
        Scanner scan = new Scanner(System.in);
        int M = scan.nextInt(); // 需要转换的十进制数
        int N = scan.nextInt(); // 转换为该进制数
        char[] s = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; // 对应表示0-15之间的数
        boolean flag = false;
        StringBuffer sb = new StringBuffer();
        if (M == 0) {
            System.out.println(M);
        }
        if (M < 0) {
            flag = true;
            M = 0 - M;
        }
        while (M > 0) {
            // 如果此时N > M 则需要用ABCDEF替换
            sb.append(s[M % N]);
            M /= N;
        }
        if (flag) {
            // 修正原本为负数的最终结果
            sb.append('-');
        }
        // 反转余数结果
        System.out.println(sb.reverse());
    }

    /**
     * A,B,C三个人是好朋友,每个人手里都有一些糖果,我们不知道他们每个人手上具体有多少个糖果,
     * 但是我们知道以下的信息A- B.B_C,A+ B,B + C.这四个数值.每个字母代表每个人所拥有的糖果数
     * 现在需要通过这四个数值计算出每个人手里有多少个糖果,即A,B,C。这里保证最多只有一组整数A,B,C满足所有题设条件
     */
    public static void fun7() {
        Scanner scan = new Scanner(System.in);
        float A, B, C;
        int y1, y2, y3, y4;
        while (scan.hasNextInt()) {
            y1 = scan.nextInt();
            y2 = scan.nextInt();
            y3 = scan.nextInt();
            y4 = scan.nextInt();
            A = (y1 + y3) / 2;
            B = (y3 - y1) / 2;
            C = (y4 - y2) / 2;
            //(B != (y2 + y4)/2)
            // 消元法
            if ((B - (y3 - y1) / 2 != 0) || (B != (y2 + y4) / 2) || (C - (y4 - y2) / 2) != 0) {
                System.out.print("No");
                return;
            }
            System.out.print((int) A + " " + (int) B + " " + (int) C);
        }
    }

    // day 5

    /**
     * 一个数组有N 个元素，求连续了数组的最大和。 例如: -1,2,1]，和最大的连续了数组为[2,11，其和为 3
     */
    public static void fun8() {

        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        long[] s = new long[N];

        // 存储数据
        for (int i = 0; i < N; i++) {
            s[i] = scan.nextInt();
        }
        long max = s[0]; // 存储最大连续值
        long sum = s[0]; // 存储当前相邻两数之和
        for (int i = 0; i < N; i++) {
            // -1  2  1
            // 从新规划sum  当首位数位负数时,
            sum = Math.max(sum, 0) + s[i];
            // 更新最大连续和
            if (max < sum) {
                max = sum;
            }
        }
        System.out.println(max);
    }

    /**
     * 判断其中一个字符串在另一个字符串得任意位置是否构成回文,
     *
     * @param s 判断是否回文
     * @return 返回回文数
     */
    public static boolean Palindrome(StringBuffer s) {
        int end = s.length() - 1;
        int start = 0;
        while (start < end) {
            if (s.charAt(start) == s.charAt(end)) {
                start++;
                end--;
            } else {
                return false;
            }
        }
        return true;
    }

    public void fun9() {
        Scanner scan = new Scanner(System.in);
        String s1 = scan.nextLine(); // 需要判断得回文串
        String s2 = scan.nextLine(); // 需要加入得字符串
        int count = 0; // 统计回文
        StringBuffer sb2 = new StringBuffer(s1);
        for (int i = 0; i < s1.length(); i++) {
            //将s2 拼接到s1中指定位置
            StringBuffer sb1 = new StringBuffer(s1);
            sb1.insert(i, s2);
            // 判断当前是否位回文
            if (Palindrome(sb1)) {
                count++;
            }
        }
        // 统计特殊位置  s2字符串位于 s1字符串末尾
        if (Palindrome(sb2.append(s2))) {
            count++;
        }
        System.out.println(count);
    }


    //day 6
    public static int a(int b) {
        try {
            b += 10;
            return b;
        } catch (RuntimeException e) {

        } catch (Exception e1) {

        } finally {
            b += 10;
            return b;
        }
    }

    /**
     * 把字符串转为整肃
     *
     * @param str 字符串
     * @return 数字整数
     */

    public static int StrToInt(String str) {
        boolean flag = false;
        int num = 0;
        for (int i = 0; i < str.length(); i++) {
            // 判断开头第一个字符是否符合
            if (i == 0 && (str.charAt(0) == '+' || str.charAt(0) == '-')) {
                // 判断是否为负数特殊情况 标记负号
                if (str.charAt(0) == '-') {
                    flag = true;
                }
            } else {
                // 此处首位字符必然符合要求
                // 其余情况 -- 排除出现a-z
                if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
                    // 存储数值并累加
                    num = (num * 10 + (str.charAt(i) - '0'));
                    // 字符串长度为 0 - 100, 可能累加可能超
                } else {
                    // 任意位置出现字母或者首位不是 + -
                    return 0;
                }
            }
        }
        return flag == true ? num * (-1) : num;
    }

    /**
     *   二货小易有一个W*H的网格盒子，网格的行编号为0~H-1，网格的列编号为0~W-1。每个格子至多可以放一块蛋糕，
     *   任意两块蛋糕的欧几里得距离不能等于2。
     * 对于两个格子坐标(x1,y1),(x2,y2)的欧几里得距离为:
     * ( (x1-x2) * (x1-x2) + (y1-y2) * (y1-y2) ) 的算术平方根
     */
    /**
     * 横纵坐标差值不能大于 2
     * <p>
     * 1 1 0 0 1 1     0 0
     * 1 1 0 0 1 1     0 0
     * 0 0 1 1 0 0     1 1
     * 0 0 1 1 0 0     1 1
     * 1 1 0 0 1 1     0 0
     * 1 1 0 0 1 1     0 0
     * <p>
     * <p>
     * 0 0 1 1 0 0     1 1
     * 0 0 1 1 0 0     1 1
     */
    public static void fun10() {
        Scanner sc = new Scanner(System.in);
        int W = sc.nextInt(); // 列数
        int H = sc.nextInt(); // 行数
        int count = 0;
        // 四列  或者 四行时 默认为一个规律的全列
        if (W % 4 == 0 || H % 4 == 0) {
            count = (W * H) / 2;

        } else if (W % 2 == 0 && H % 2 == 0) {
            //  列 或者 行部位四的偶数列时, 比起全列情况下 多上共有的两个蛋糕
            count = (W * H) / 2 + 2;
        } else {
            //  奇数列 以及 奇数行
            count = (W * H) / 2 + 1;
        }
        System.out.println(count);
    }

    // day 7

    /**
     * 括号匹配机制  ((()))  true   (( a )) false
     * @return
     */
    public static boolean fun11() {
        Scanner scanner = new Scanner(System.in);
        String A = scanner.nextLine();
        int n = scanner.nextInt();
        Queue<Character> queue = new LinkedList<>();
        for (int i = 0; i < A.length(); i++) {
            if (A.charAt(i) == '(') {
                queue.add(A.charAt(i));
            } else if (A.charAt(i) == ')') {
                if (queue.isEmpty()) {
                    return false;
                }
                queue.poll();
            } else {
                if (A.charAt(i) != ' ') {
                    return false;
                }
            }
        }
        return queue.isEmpty();
    }

    public void moveZeroes(int[] nums) {
        // 双指针
        int left = 0;
        int right = 0;
        // && left < nums.length
        while(right < nums.length) {
            //left 左指针指向当前已经处理好的序列尾部
            while(left < nums.length) {
                if(nums[left] == 0) {
                    break;
                }
                left++;
            }

            if(left >= nums.length) {
                break;
            }
            // right 寻找非0
            while(right < nums.length) {
                if(nums[right] != 0 && right != 0) {
                    swap(nums, left , right);
                    break;
                }
                right++;
            }
            // right 遍历一次即表示所有的非0寻找完了
            left++;
            right++;
        }
    }

    public void swap(int[] nums, int left, int right) {
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
    }

    public static void main(String[] args) {
        int[] arr1 = {0,1,0,3,12};
//        int[] arr2 = {0,1,0,3,12};
//        int[] arr3 = {0};
        test T = new test();
        T.moveZeroes(arr1);
        System.out.println(Arrays.toString(arr1));
//        T.moveZeroes(arr2);
//        System.out.println(Arrays.toString(arr2));
//        T.moveZeroes(arr3);
//        System.out.println(Arrays.toString(arr3));

    }

    public static void main1(String[] args) {
        /*String s1  = "zhangasn";
        for (int i = 0; i < s1.length(); i++) {
            //int ret = s1.codePointAt(i);
            //System.out.println(ret);

        }*/
        //fun2();
        //test t = new test();

        //System.out.println(fun2());
        //fun3();
        /*String s = "I like Beijing.";
        fun4(s);*/
        /*System.out.println(t.i);
        System.out.println(test.i);*/

        //fun4();
/*        System.out.println(a(10));
        ;
        boolean s = true ? false : true == true ? false : true;
        System.out.println(s);
        long b =  012;
        double x = 0x122234;
        System.out.println(x);*/
        /*int ret = StrToInt("-123");
        System.out.println(ret);*/
//        System.out.println(fun11());
        //ystem.out.println(2%4);


    }
}
